
import numpy as np
import pickle as pkl
import tensorflow as tf
from tensorflow.keras.applications.resnet50 import ResNet50,preprocess_input
from tensorflow.keras.preprocessing import image
from tensorflow.keras.layers import GlobalMaxPool2D

from sklearn.neighbors import NearestNeighbors
import os #to import the images names from image folder
from numpy.linalg import norm


path='E:/FTE/Projects/DL/Fashion/images'
filenames = []
for file in os.listdir(path):
    filenames.append(os.path.join(path,file))


len(filenames)

44441


model= ResNet50(weights='imagenet',include_top=False, input_shape=(224,224,3))
model.trainable =False  #we are not training the model as we are using pretrained model

model=tf.keras.models.Sequential([model,GlobalMaxPool2D()])
model.summary()

Model: "sequential"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓
┃ Layer (type)                         ┃ Output Shape                ┃         Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩
│ resnet50 (Functional)                │ (None, 7, 7, 2048)          │      23,587,712 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ global_max_pooling2d                 │ (None, 2048)                │               0 │
│ (GlobalMaxPooling2D)                 │                             │                 │
└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘

 Total params: 23,587,712 (89.98 MB)

 Trainable params: 0 (0.00 B)

 Non-trainable params: 23,587,712 (89.98 MB)


img=image.load_img('54656.jpg',target_size=(224,224))
img_array= image.img_to_array(img)
img_array

array([[[255., 255., 255.],
        [255., 255., 255.],
        [255., 255., 255.],
        ...,
        [255., 255., 255.],
        [255., 255., 255.],
        [255., 255., 255.]],

       [[255., 255., 255.],
        [255., 255., 255.],
        [255., 255., 255.],
        ...,
        [255., 255., 255.],
        [255., 255., 255.],
        [255., 255., 255.]],

       [[255., 255., 255.],
        [255., 255., 255.],
        [255., 255., 255.],
        ...,
        [255., 255., 255.],
        [255., 255., 255.],
        [255., 255., 255.]],

       ...,

       [[255., 255., 255.],
        [255., 255., 255.],
        [255., 255., 255.],
        ...,
        [255., 255., 255.],
        [255., 255., 255.],
        [255., 255., 255.]],

       [[255., 255., 255.],
        [255., 255., 255.],
        [255., 255., 255.],
        ...,
        [255., 255., 255.],
        [255., 255., 255.],
        [255., 255., 255.]],

       [[255., 255., 255.],
        [255., 255., 255.],
        [255., 255., 255.],
        ...,
        [255., 255., 255.],
        [255., 255., 255.],
        [255., 255., 255.]]], dtype=float32)


img_array.shape

(224, 224, 3)


img_expand_dim=np.expand_dims(img_array,axis=0)
img_expand_dim.shape

(1, 224, 224, 3)


img_preprocess= preprocess_input(img_expand_dim)
#now we have to fit it to the model and make prediction
result=model.predict(img_preprocess).flatten()   ##flatten()--returns array in 1D from 2D
result

1/1 ━━━━━━━━━━━━━━━━━━━━ 4s 4s/step

array([0.8230597, 7.3155756, 3.181357 , ..., 0.       , 8.227653 ,
       1.2007859], dtype=float32)


norm_result=result/norm(result)
norm_result

array([0.0024294 , 0.02159317, 0.00939032, ..., 0.        , 0.02428532,
       0.00354432], dtype=float32)


def extract_features_from_images(image_path, model):   
    img=image.load_img(image_path,target_size=(224,224)) 
    img_array= image.img_to_array(img)
    img_array
    img_expand_dim=np.expand_dims(img_array,axis=0)
    img_preprocess= preprocess_input(img_expand_dim)
    result=model.predict(img_preprocess).flatten()
    norm_result=result/norm(result)
    return norm_result


extract_features_from_images(filenames[0],model)

1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 200ms/step

array([0.        , 0.01761617, 0.00171604, ..., 0.01247241, 0.02726403,
       0.06899223], dtype=float32)


from tqdm import tqdm


image_features=[]
for file in tqdm(filenames[0:22000]):
    image_features.append(extract_features_from_images(file,model))
image_features

  0%|                                                                                        | 0/22000 [00:00<?, ?it/s]

1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 165ms/step

  0%|                                                                              | 1/22000 [00:00<1:34:22,  3.89it/s]

1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 153ms/step

  0%|                                                                              | 2/22000 [00:00<1:33:23,  3.93it/s]

1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 154ms/step

  0%|                                                                              | 3/22000 [00:00<1:29:38,  4.09it/s]

1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 181ms/step

  0%|                                                                              | 4/22000 [00:01<1:32:17,  3.97it/s]

1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 131ms/step


pkl.dump(image_features, open('Image_features.pkl','wb'))


pkl.dump(filenames, open('filenames.pkl','wb'))


Image_features=pkl.load(open('Image_features.pkl','rb'))


filenames=pkl.load(open('filenames.pkl','rb'))


Image_features = np.array(Image_features, dtype=np.float16)
print(Image_features.shape)

(22000, 2048)


neighbors= NearestNeighbors(n_neighbors=6, algorithm='brute', metric='euclidean')


neighbors.fit(Image_features)

NearestNeighbors(algorithm='brute', metric='euclidean', n_neighbors=6)

NearestNeighbors(algorithm='brute', metric='euclidean', n_neighbors=6)


input_image=extract_features_from_images('54656.jpg', model)

1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 87ms/step


input_image = np.array(input_image, dtype=np.float32)
neighbors._fit_X = neighbors._fit_X.astype(np.float32)  # Ensure the model data is float32

distance, indices = neighbors.kneighbors([input_image])


indices[0]

array([13358,  8501, 13384, 20797, 13361, 20082], dtype=int64)


from IPython.display import Image


Image('54656.jpg')


import matplotlib.pyplot as plt
import matplotlib.image as mpimg


def display_images(filenames, indices):
    plt.figure(figsize=(20, 5))  # Create a figure with a specific size

    # Loop through the first 5 recommended images
    for i in range(5):
        img_path = filenames[indices[0][i + 1]]  # Get the path of the recommended image
        img = mpimg.imread(img_path)  # Read the image
        
        # Add a subplot for each image
        plt.subplot(1, 5, i + 1)  # 1 row, 5 columns, position i+1
        plt.imshow(img)  # Display the image
        plt.axis('off')  # Turn off the axes
        plt.title(f"Recommendation {i + 1}")  # Add a title for each image

    plt.tight_layout()
    plt.show()  # Show all images

# Example Usage
display_images(filenames, indices)

Here we not building the CNN model from the scratch,rather we are using pretrained model(already trained on huge dataset).¶

So I have imported the model and configured it according to requirements¶

Here I am using the Resnet50 CNN model(this model is trained on imagenet with more than millions of images)¶

Import Libraries¶

Extract filenames from Folder¶

Importing ResNet50 Model and Configuration¶

*Note¶

Extract 2048 features from the images¶

Save the features¶

Find the similar images¶